For multitasking computer systems, the term “starvation” describes the problem condition where a process is denied necessary resources for an extended period of time, or even perpetually. In particular, starvation is a problem for licensed software programs, where client users may have to share a limited number of licenses granting access to a shared-license application. Typically, in such shared-license application systems there are generally three forms of starvation that may occur when two users, A and B, require the use of a shared-license application.
The first form of starvation can be referred to as a greedy running process (GRP). In a GRP scenario, User A may start a long-running license-holding job at time t0. Shortly thereafter, at time t1, user B may want to start a job that needs the same license as user A. Before user B can begin, however, it must wait for a potentially long time (or indefinitely), until user A finishes at time t2.
The second form of starvation can be referred to as a greedy idle process (GIP). The GIP scenario occurs when an application is idle while holding a license. For example, user A may start a license-holding application at time t0 and then stop using the application without terminating it. User B, again wanting to access the application at time t1, must wait for a potentially long time (or indefinitely) until user A terminates the application at time t2.
The third form of starvation can be referred to as a greedy dead process (GDP). If an application holding a license unexpectedly (or expectedly) dies before it gets a chance to return the license, the license will be unavailable until someone—either a user of the system or the license system itself—realizes that the application has died and takes the necessary steps to recover its licenses.
The problem of sharing a limited number of software licenses among a large number of applications is analogous to the classic operating system (OS) problem of sharing limited resources among a potentially large number of processes, while guaranteeing that no process starves waiting for a resource. In the case of software licenses, however, an obstruction to solving the starvation problem at the OS level is that the various machines whose processes share a given license know nothing about the license requirements of processes executing on other machines. Therefore, the end user may have no way to work around a poorly behaving application, short of not executing it in the first place.